// fund.ts
// 导入IndexedDB服务
import { getAllFunds, batchUpdateFunds, type FundItem } from '@/data/InvestmentDB'
import { fundApi, realTimeValuationsApi } from '@/api/modules/Fund'

let fundData: FundItem[] = []

// 刷新表格数据
export const refreshFundsData = async () => {
  try {
    const data = await getAllFunds()
    fundData = data
    await fetchFundData() // 等待数据更新完成
  } catch (error) {
    console.error('刷新基金数据失败:', error) // 修正日志描述
  } finally {
    // loading.close()
  }
}

// 获取基金数据并更新
const fetchFundData = async () => {
  // 常量定义，提高可维护性
  const MAX_RETRY = 1 // 重试次数
  const RETRY_DELAY = 1000 // 重试延迟(ms)

  if (fundData.length === 0) {
    console.log('无基金数据可更新')
    return []
  }

  try {
    // 使用Promise.allSettled确保单个请求失败不影响整体
    const results = await Promise.allSettled(
      fundData.map(async (item) => {
        const code = item.code
        if (!code || typeof code !== 'string' || !/^\d{6}$/.test(code)) {
          console.warn('无效的基金代码，跳过更新', item)
          return null
        }

        // 带重试的API请求
        let retryCount = 0
        while (retryCount <= MAX_RETRY) {
          try {
            // 并行请求基金基础数据和实时估值
            // const [fundDetailRes, valuationRes] = await Promise.all([
            //   fundApi(code),
            //   realTimeValuationsApi(code),
            // ])
            const fundDetailRes = await fundApi(code)
            let valuationData = {}
            if (item.fundType !== 'QDII') {
              const valuationRes = await realTimeValuationsApi(code)
              // 处理实时估值数据（解析JSONP格式）
              valuationData = parseValuationResponse(valuationRes)
            }
            if (!valuationData) {
              throw new Error('实时估值数据解析失败')
            }

            // 合并数据并更新
            updateFundItemData(
              item,
              {
                ...fundDetailRes.data,
                ...valuationData,
              },
              code,
            )

            return { code, status: 'success', item }
          } catch (error) {
            retryCount++
            if (retryCount > MAX_RETRY) {
              console.error(`获取基金 ${code} 数据失败（已重试${MAX_RETRY}次）:`, error)
              return { code, status: 'error', error }
            }
            console.warn(`获取基金 ${code} 数据失败，正在重试（${retryCount}/${MAX_RETRY}）`)
            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY))
          }
        }
      }),
    )

    // 筛选成功更新的基金数据
    const updatedFunds = results
      .filter((r) => r.status === 'fulfilled' && r.value?.status === 'success' && r.value.item)
      .map((r) => (r as PromiseFulfilledResult<{ item: FundItem }>).value.item)

    // 执行批量更新
    if (updatedFunds.length > 0) {
      await batchUpdateFunds(updatedFunds)
      console.log(`已成功批量更新 ${updatedFunds.length} 条基金数据到本地数据库`)
    }

    // 统计更新结果
    const totalCount = fundData.length
    const successCount = updatedFunds.length
    console.log(`基金数据更新完成: 成功 ${successCount}/${totalCount}`)

    if (totalCount - successCount > 0) {
      console.error(`部分基金数据更新失败 (${totalCount - successCount}/${totalCount})`)
    }

    return results
  } catch (error) {
    console.error('基金数据更新整体失败:', error)
    return []
  }
}

// 解析估值响应数据（JSONP格式）
const parseValuationResponse = (response: string): Record<string, any> | null => {
  try {
    // 提取JSON部分并解析
    const jsonMatch = response.match(/^jsonpgz\((.*)\);$/)
    if (!jsonMatch || !jsonMatch[1]) {
      throw new Error('估值数据格式不正确')
    }
    return JSON.parse(jsonMatch[1])
  } catch (error) {
    console.error('解析估值数据失败:', error)
    return null
  }
}

// 更新基金项目数据
const updateFundItemData = (item: FundItem, data: any, code: string) => {
  // 基础信息更新
  item.name = data.fd_name || item.name || '未知基金'
  item.code = code // 确保代码正确

  // 净值数据处理（基金净值通常保留4位小数）
  // const prevNetValue = Number(data.fund_derived?.unit_nav) || 0
  // const currentNetValue = Number(data.gsz) || prevNetValue || 0
  let prevNetValue = 0,
    currentNetValue = 0
  if (item.fundType === 'QDII') {
    prevNetValue = Number(data.fund_derived?.unit_nav) - Number(data.fund_derived?.nav_growth) || 0
    currentNetValue = Number(data.fund_derived?.unit_nav) || 0
    item.lastUpdated = data.fund_derived?.end_date
  } else {
    prevNetValue = Number(data.dwjz) || 0
    currentNetValue = Number(data.gsz) || prevNetValue || 0
    item.lastUpdated = data.gztime
  }

  item.preClose = prevNetValue.toFixed(4)
  item.price = currentNetValue.toFixed(4)

  // 计算涨跌幅（处理昨日净值为0的边界情况）
  if (prevNetValue > 0) {
    const changePercent = (((currentNetValue - prevNetValue) / prevNetValue) * 100).toFixed(2)
    item.change = changePercent
  } else {
    item.change = '0.00'
    console.warn(`基金 ${code} 昨日净值异常，涨跌幅计算失败`)
  }

  // 计算财务指标（转换为数字类型处理）
  const cost = Number(item.cost) || 0
  const holdings = Number(item.holdings) || 0
  const tax = Number(item.tax) || 0

  // 投入金额 = 成本价 × 持仓数量
  item.investment = holdings > 0 && cost > 0 ? (cost * holdings).toFixed(2) : '0.00'

  // 持仓金额 = 当前净值 × 持仓数量
  item.holdingValue =
    holdings > 0 && currentNetValue > 0 ? (currentNetValue * holdings).toFixed(2) : '0.00'

  // 总盈亏 = 持仓金额 - 投入金额 - 税费
  const investment = Number(item.investment)
  const holdingValue = Number(item.holdingValue)
  item.profit = (holdingValue - investment - tax).toFixed(2)

  // 持仓盈亏率 = (总盈亏 / 投入金额) * 100
  item.profitRate = investment > 0 ? ((Number(item.profit) / investment) * 100).toFixed(2) : '0.00'

  // 今日盈亏 = (当前净值 - 昨日净值) × 持仓数量
  item.todayProfit =
    holdings > 0 && prevNetValue > 0
      ? ((currentNetValue - prevNetValue) * holdings).toFixed(2)
      : '0.00'

  // // 记录最后更新时间
  // if (item.fundType === 'QDII') {
  //   item.lastUpdated = data.fund_derived?.end_date
  // } else {
  //   item.lastUpdated = data.gztime
  // }
}
